/**
 * 简单的依赖注入容器
 * 解决SDK全局访问问题，提供类型安全的服务获取
 */

/**
 * 服务标识符
 */
export type ServiceIdentifier<T = any> = string | symbol | (new (...args: any[]) => T);

/**
 * 服务工厂函数
 */
export type ServiceFactory<T = any> = () => T | Promise<T>;

/**
 * 服务生命周期
 */
export enum ServiceLifetime {
    SINGLETON = 'singleton',    // 单例，全局共享
    TRANSIENT = 'transient',    // 每次获取都创建新实例
    SCOPED = 'scoped'           // 作用域内单例（暂不实现）
}

/**
 * 服务注册信息
 */
interface ServiceRegistration<T = any> {
    identifier: ServiceIdentifier<T>;
    factory: ServiceFactory<T>;
    lifetime: ServiceLifetime;
    instance?: T;
}

/**
 * 服务容器
 */
export class ServiceContainer {
    private services = new Map<ServiceIdentifier, ServiceRegistration>();
    private static instance: ServiceContainer;

    constructor() {
        if (ServiceContainer.instance) {
            return ServiceContainer.instance;
        }
        ServiceContainer.instance = this;
    }

    /**
     * 获取全局容器实例
     */
    static getInstance(): ServiceContainer {
        if (!ServiceContainer.instance) {
            ServiceContainer.instance = new ServiceContainer();
        }
        return ServiceContainer.instance;
    }

    /**
     * 注册单例服务
     */
    registerSingleton<T>(identifier: ServiceIdentifier<T>, factory: ServiceFactory<T>): void {
        this.register(identifier, factory, ServiceLifetime.SINGLETON);
    }

    /**
     * 注册临时服务
     */
    registerTransient<T>(identifier: ServiceIdentifier<T>, factory: ServiceFactory<T>): void {
        this.register(identifier, factory, ServiceLifetime.TRANSIENT);
    }

    /**
     * 注册服务实例
     */
    registerInstance<T>(identifier: ServiceIdentifier<T>, instance: T): void {
        this.services.set(identifier, {
            identifier,
            factory: () => instance,
            lifetime: ServiceLifetime.SINGLETON,
            instance
        });
    }

    /**
     * 注册服务
     */
    private register<T>(
        identifier: ServiceIdentifier<T>,
        factory: ServiceFactory<T>,
        lifetime: ServiceLifetime
    ): void {
        this.services.set(identifier, {
            identifier,
            factory,
            lifetime
        });
    }

    /**
     * 获取服务
     */
    async get<T>(identifier: ServiceIdentifier<T>): Promise<T> {
        const registration = this.services.get(identifier);
        if (!registration) {
            throw new Error(`Service not registered: ${String(identifier)}`);
        }

        // 单例模式：检查是否已有实例
        if (registration.lifetime === ServiceLifetime.SINGLETON && registration.instance) {
            return registration.instance;
        }

        // 创建实例
        const instance = await registration.factory();

        // 单例模式：缓存实例
        if (registration.lifetime === ServiceLifetime.SINGLETON) {
            registration.instance = instance;
        }

        return instance;
    }

    /**
     * 同步获取服务（仅适用于同步工厂函数）
     */
    getSync<T>(identifier: ServiceIdentifier<T>): T {
        const registration = this.services.get(identifier);
        if (!registration) {
            throw new Error(`Service not registered: ${String(identifier)}`);
        }

        // 单例模式：检查是否已有实例
        if (registration.lifetime === ServiceLifetime.SINGLETON && registration.instance) {
            return registration.instance;
        }

        // 创建实例（同步）
        const instance = registration.factory() as T;

        // 单例模式：缓存实例
        if (registration.lifetime === ServiceLifetime.SINGLETON) {
            registration.instance = instance;
        }

        return instance;
    }

    /**
     * 检查服务是否已注册
     */
    has(identifier: ServiceIdentifier): boolean {
        return this.services.has(identifier);
    }

    /**
     * 移除服务注册
     */
    remove(identifier: ServiceIdentifier): boolean {
        return this.services.delete(identifier);
    }

    /**
     * 清空所有服务
     */
    clear(): void {
        this.services.clear();
    }

    /**
     * 获取已注册的服务数量
     */
    size(): number {
        return this.services.size;
    }

    /**
     * 获取所有已注册的服务标识符
     */
    getRegisteredServices(): ServiceIdentifier[] {
        return Array.from(this.services.keys());
    }
}

/**
 * 服务标识符常量
 * 为常用服务提供类型安全的标识符
 */
export const ServiceIdentifiers = {
    // 用户管理
    USER_MANAGER: Symbol('UserManager'),
    
    // 邮件管理
    MAIL_MANAGER: Symbol('MailManager'),
    
    // 背包服务
    BAG_SERVICE: Symbol('BagService'),
    BAG_REPOSITORY: Symbol('BagRepository'),
    
    // RPG服务
    RPG_SERVICE: Symbol('RPGService'),
    RPG_REPOSITORY: Symbol('RPGRepository'),
    
    // 签到服务
    SIGN_SERVICE: Symbol('SignService'),
    
    // 意图服务
    INTENT_SERVICE: Symbol('IntentService'),
    
    // 工具服务
    COMMON_TOOLS: Symbol('CommonTools'),
    CARD_TOOLS: Symbol('CardTools'),
    DB_INSTANCE: Symbol('DBInstance'),
    
    // 管理器
    SCENE_MANAGER: Symbol('SceneManager'),
    COMPONENT_MANAGER: Symbol('ComponentManager'),
    CLIENT_MANAGER: Symbol('ClientManager'),
    
    // 缓存
    GLOBAL_CACHE: Symbol('GlobalCache'),
    REPOSITORY_HELPER: Symbol('RepositoryHelper')
} as const;

/**
 * 全局容器实例
 */
export const container = ServiceContainer.getInstance();

/**
 * 便捷的注入装饰器（可选使用）
 */
export function inject<T>(identifier: ServiceIdentifier<T>) {
    return function (target: any, propertyKey: string | symbol) {
        // 这里可以实现属性注入逻辑
        // 暂时简化处理
        Object.defineProperty(target, propertyKey, {
            get: () => container.getSync(identifier),
            enumerable: true,
            configurable: true
        });
    };
}

/**
 * 基础服务类
 * 提供依赖注入的基础功能
 */
export abstract class BaseService {
    protected container: ServiceContainer;

    constructor() {
        this.container = container;
    }

    /**
     * 获取依赖服务
     */
    protected async getService<T>(identifier: ServiceIdentifier<T>): Promise<T> {
        return this.container.get(identifier);
    }

    /**
     * 同步获取依赖服务
     */
    protected getServiceSync<T>(identifier: ServiceIdentifier<T>): T {
        return this.container.getSync(identifier);
    }
}

/**
 * API上下文
 * 为API提供统一的服务访问接口
 */
export class ApiContext extends BaseService {
    /**
     * 获取用户管理器
     */
    get userManager() {
        return this.getServiceSync(ServiceIdentifiers.USER_MANAGER);
    }

    /**
     * 获取邮件管理器
     */
    get mailManager() {
        return this.getServiceSync(ServiceIdentifiers.MAIL_MANAGER);
    }

    /**
     * 获取背包服务
     */
    get bagService() {
        return this.getServiceSync(ServiceIdentifiers.BAG_SERVICE);
    }

    /**
     * 获取RPG服务
     */
    get rpgService() {
        return this.getServiceSync(ServiceIdentifiers.RPG_SERVICE);
    }

    /**
     * 获取签到服务
     */
    get signService() {
        return this.getServiceSync(ServiceIdentifiers.SIGN_SERVICE);
    }

    /**
     * 获取意图服务
     */
    get intentService() {
        return this.getServiceSync(ServiceIdentifiers.INTENT_SERVICE);
    }

    /**
     * 获取通用工具
     */
    get commonTools() {
        return this.getServiceSync(ServiceIdentifiers.COMMON_TOOLS);
    }

    /**
     * 获取卡片工具
     */
    get cardTools() {
        return this.getServiceSync(ServiceIdentifiers.CARD_TOOLS);
    }

    /**
     * 获取场景管理器
     */
    get sceneManager() {
        return this.getServiceSync(ServiceIdentifiers.SCENE_MANAGER);
    }

    /**
     * 获取客户端管理器
     */
    get clientManager() {
        return this.getServiceSync(ServiceIdentifiers.CLIENT_MANAGER);
    }
}

/**
 * 创建API上下文
 */
export function createApiContext(): ApiContext {
    return new ApiContext();
}
